home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / share / hplip / base / maint.py < prev    next >
Text File  |  2008-10-13  |  43KB  |  1,421 lines
  1. # -*- coding: utf-8 -*-
  2. #
  3. # (c) Copyright 2003-2007 Hewlett-Packard Development Company, L.P.
  4. #
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 2 of the License, or
  8. # (at your option) any later version.
  9. #
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14. #
  15. # You should have received a copy of the GNU General Public License
  16. # along with this program; if not, write to the Free Software
  17. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18. #
  19. # Author: Don Welch
  20. #
  21.  
  22. # Local
  23. from g import *
  24. from codes import *
  25. import status, pml
  26. from prnt import pcl, ldl, colorcal
  27.  
  28. # ********************** Align **********************
  29.  
  30. def AlignType1(dev, loadpaper_ui): # Auto VIP (using embedded PML)
  31.     ok = loadpaper_ui()
  32.     if ok:
  33.         dev.writeEmbeddedPML(pml.OID_AUTO_ALIGNMENT,
  34.                              pml.AUTO_ALIGNMENT, style=0, 
  35.                              direct=True)
  36.         dev.closePrint()
  37.  
  38.     return ok
  39.     
  40. def AlignType1PML(dev, loadpaper_ui): # Auto VIP (using PML)
  41.     ok = loadpaper_ui()
  42.     if ok:
  43.         dev.setPML(pml.OID_AUTO_ALIGNMENT, pml.AUTO_ALIGNMENT)
  44.         dev.closePML()
  45.  
  46.     return ok
  47.  
  48.  
  49.  
  50. def AlignType2(dev, loadpaper_ui, align_ui, bothpens_ui): # 8xx
  51.     state, a, b, c, d = 0, 6, 6, 3, 3
  52.     ok = False
  53.     while state != -1:
  54.         if state == 0:
  55.             state = 1
  56.             pens = dev.getStatusFromDeviceID()['agents']
  57.             pen_types = [pens[x] for x in range(len(pens))]
  58.             if AGENT_TYPE_NONE in pen_types:
  59.                 log.error("Cannot perform alignment with 0 or 1 pen installed.")
  60.                 state = 100
  61.  
  62.         elif state == 1:
  63.             state = -1
  64.             ok = loadpaper_ui()
  65.             if ok:
  66.                 state = 2
  67.  
  68.         elif state == 2:
  69.             state = -1
  70.             alignType2Phase1(dev)
  71.             ok, a = align_ui('A', 'h', 'kc', 2, 11)
  72.             if ok:
  73.                 state = 3
  74.  
  75.         elif state == 3:
  76.             state = -1
  77.             ok, b = align_ui('B', 'v', 'kc', 2, 11)
  78.             if ok:
  79.                 state = 4
  80.  
  81.         elif state == 4:
  82.             state = -1
  83.             ok, c = align_ui('C', 'v', 'kc', 2, 5)
  84.             if ok:
  85.                 state = 5
  86.  
  87.         elif state == 5:
  88.             state = -1
  89.             ok, d = align_ui('D', 'v', 'c', 2, 5)
  90.             if ok:
  91.                 state = 6
  92.  
  93.         elif state == 6:
  94.             ok = loadpaper_ui()
  95.             if ok:
  96.                 alignType2Phase2(dev, a, b, c, d)
  97.             state = -1
  98.  
  99.         elif state == 100:
  100.             ok = False
  101.             bothpens_ui()
  102.             state = -1
  103.  
  104.     return ok
  105.  
  106.  
  107.  
  108. def AlignType3(dev, loadpaper_ui, align_ui, paperedge_ui, align_type): # 9xx
  109.     state, a, b, c, d, zca = 0, 6, 6, 3, 3, 6
  110.     ok = False
  111.     while state != -1:
  112.         if state == 0:
  113.             state = -1
  114.             ok = loadpaper_ui()
  115.             if ok:
  116.                 alignType3Phase1(dev)
  117.                 state = 1
  118.  
  119.         elif state == 1:
  120.             state = -1
  121.             ok, a = align_ui('A', 'h', 'kc', 2, 11)
  122.             if ok:
  123.                 state = 2
  124.  
  125.         elif state == 2:
  126.             state = -1
  127.             ok, b = align_ui('B', 'v', 'kc', 2, 11)
  128.             if ok:
  129.                 state = 3
  130.  
  131.         elif state == 3:
  132.             state = -1
  133.             ok, c = align_ui('C', 'v', 'k', 2, 11)
  134.             if ok:
  135.                 state = 4
  136.  
  137.         elif state == 4:
  138.             state = -1
  139.             ok, d = align_ui('D', 'v', 'kc', 2, 11)
  140.             if ok:
  141.                 state = 5
  142.  
  143.         elif state == 5:
  144.             state = -1
  145.             alignType3Phase2(dev, a, b, c, d)
  146.             if align_type == 9:
  147.                 state = 7
  148.             else:
  149.                 ok = loadpaper_ui()
  150.                 if ok:
  151.                     state = 6
  152.  
  153.         elif state == 6:
  154.             state = -1
  155.             alignType3Phase3(dev)
  156.             ok, zca = paperedge_ui(13)
  157.             if ok:
  158.                 state = 7
  159.  
  160.         elif state == 7:
  161.             ok = loadpaper_ui()
  162.             if ok:
  163.                 alignType3Phase4(dev, zca)
  164.             state = -1
  165.  
  166.     return ok
  167.  
  168.  
  169. def AlignxBow(dev, align_type, loadpaper_ui, align_ui, paperedge_ui,
  170.                invalidpen_ui, coloradj_ui): # Types 4, 5, and 7
  171.  
  172.     state, statepos = 0, 0
  173.     user_cancel_states = [1000, -1]
  174.     a, b, c, d, e, f, g = 0, 0, 0, 0, 0, 0, 0
  175.     error_states = [-1]
  176.     ok = False
  177.  
  178.     dev.pen_config = status.getPenConfiguration(dev.getStatusFromDeviceID())
  179.  
  180.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  181.         state, states = 100, [-1]
  182.  
  183.     elif dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  184.         state, states = 0, [2, 200, 3, -1]
  185.  
  186.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  187.         state, states = 0, [2, 200, 3, -1]
  188.  
  189.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  190.         state, states = 0, [2, 300, 3, -1]
  191.  
  192.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  193.         state, states = 0, [2, 400, 500, 600, 700, 3, 4, -1]
  194.  
  195.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  196.         state, states = 0, [2, 400, 500, 600, 700, 800, 900, 3, 4, -1]
  197.  
  198.     while state != -1:
  199.  
  200.         if state == 0:
  201.             ok = loadpaper_ui()
  202.             if ok:
  203.                 if align_type == 4:
  204.                     alignType4Phase1(dev)
  205.                 elif align_type == 5:
  206.                     alignType5Phase1(dev)
  207.                 elif align_type == 7:
  208.                     alignType7Phase1(dev)
  209.                 else:
  210.                     statepos, states = 0, error_states
  211.             else:
  212.                 statepos, states = 0, user_cancel_states
  213.  
  214.  
  215.         elif state == 2:
  216.             ok, a = paperedge_ui(13)
  217.             if not ok:
  218.                 statepos, states = 0, user_cancel_states
  219.  
  220.         elif state == 3:
  221.             if align_type == 4:
  222.                 alignType4Phase2(dev, a, b, c, d, e)
  223.             elif align_type == 5:
  224.                 alignType5Phase2(dev, a, b, c, d, e, f, g)
  225.             else:
  226.                 alignType7Phase2(dev, a, b, c, d, e, f, g)
  227.  
  228.         elif state == 4:
  229.             ok = loadpaper_ui()
  230.             if ok:
  231.                 if align_type == 4:
  232.                     alignType4Phase3(dev)
  233.                 elif align_type == 5:
  234.                     alignType5Phase3(dev)
  235.                 else:
  236.                     alignType7Phase3(dev)
  237.             else:
  238.                 statepos, states = 0, user_cancel_states
  239.  
  240.         elif state == 100:
  241.             invalidpen_ui()
  242.             state = -1
  243.  
  244.         elif state == 200: # B Line - Black only or photo only
  245.             ok, b = align_ui('B', 'v', 'k', 2, 11)
  246.             if not ok:
  247.                 statepos, states = 0, user_cancel_states
  248.  
  249.         elif state == 300: # B Line - Color only
  250.             ok, b = align_ui('B', 'v', 'kc', 2, 11)
  251.             if not ok:
  252.                 statepos, states = 0, user_cancel_states
  253.  
  254.         elif state == 400: # B Line - 2 pen
  255.             ok, b = align_ui('B', 'h', 'kc', 2, 17)
  256.             if not ok:
  257.                 statepos, states = 0, user_cancel_states
  258.  
  259.         elif state == 500: # C Line
  260.             ok, c = align_ui('C', 'v', 'kc', 2, 17)
  261.             if not ok:
  262.                 statepos, states = 0, user_cancel_states
  263.  
  264.         elif state == 600 : # D Line
  265.             ok, d = align_ui('D', 'v', 'k', 2, 11)
  266.             if not ok:
  267.                 statepos, states = 0, user_cancel_states
  268.  
  269.         elif state == 700: # E Line
  270.             ok, e = align_ui('E', 'v', 'kc', 2, 11)
  271.             if not ok:
  272.                 statepos, states = 0, user_cancel_states
  273.  
  274.         elif state == 800: # F Line
  275.             ok, f = coloradj_ui('F', 21)
  276.             if not ok:
  277.                 statepos, states = 0, user_cancel_states
  278.  
  279.         elif state == 900: # G Line
  280.             ok, f = coloradj_ui('G', 21)
  281.             if not ok:
  282.                 statepos, states = 0, user_cancel_states
  283.  
  284.         elif state == 1000: # User cancel
  285.             ok = False
  286.             log.warning("Alignment canceled at user request.")
  287.  
  288.         state = states[statepos]
  289.         statepos += 1
  290.  
  291.     return ok
  292.  
  293.  
  294. def AlignType6(dev, ui1, ui2, loadpaper_ui):
  295.     state = 0
  296.     ok = False
  297.  
  298.     while state != -1:
  299.         if state == 0:
  300.             state = 2
  301.             accept = ui1()
  302.             if not accept:
  303.                 # Need to printout alignment page
  304.                 state = 1
  305.  
  306.         elif state == 1: # Load and print
  307.             state = -1
  308.             ok = loadpaper_ui()
  309.             if ok:
  310.                 alignType6Phase1(dev)
  311.                 state = 2
  312.  
  313.         elif state == 2: # Finish
  314.             ui2()
  315.             state = -1
  316.  
  317.  
  318.     return ok
  319.  
  320. def AlignType8(dev, loadpaper_ui, align_ui): # 450
  321.     state, a, b, c, d = 0, 5, 5, 5, 5
  322.     ok = False
  323.  
  324.     while state != -1:
  325.  
  326.         if state == 0:
  327.             state = -1
  328.             ok = loadpaper_ui()
  329.             if ok:
  330.                 num_inks = alignType8Phase1(dev)
  331.                 state = 1
  332.  
  333.         elif state == 1:
  334.             state = -1
  335.             ok, a = align_ui('A', 'v', 'k', 3, 9)
  336.             if ok:
  337.                 state = 2
  338.  
  339.         elif state == 2:
  340.             state = -1
  341.             ok, b = align_ui('B', 'v', 'c', 3, 9)
  342.             if ok:
  343.                 state = 3
  344.  
  345.         elif state == 3:
  346.             state = -1
  347.             ok, c = align_ui('C', 'v', 'kc', 3, 9)
  348.             if ok:
  349.                 state = 4
  350.  
  351.         elif state == 4:
  352.             state = -1
  353.             ok, d = align_ui('D', 'h', 'kc', 3, 9)
  354.             if ok:
  355.                 state = 5
  356.  
  357.         elif state == 5:
  358.             alignType8Phase2(dev, num_inks, a, b, c, d)
  359.             state = -1
  360.  
  361.     return ok
  362.  
  363.  
  364. def AlignType10(dev, loadpaper_ui, align_ui):
  365.     pen_config = status.getPenConfiguration(dev.getStatusFromDeviceID())
  366.     log.debug("Pen config=%d" % pen_config)
  367.  
  368.     if pen_config == AGENT_CONFIG_BLACK_ONLY:
  369.         pattern = 1
  370.  
  371.     elif pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  372.         pattern = 2
  373.  
  374.     elif pen_config in (AGENT_CONFIG_COLOR_AND_PHOTO, AGENT_CONFIG_COLOR_AND_GREY):
  375.         pattern = 3
  376.  
  377.     log.debug("Pattern=%d" % pattern)
  378.  
  379.     state = 0
  380.  
  381.     while state != -1:
  382.         if state == 0:
  383.             state = -1
  384.             ok = loadpaper_ui()
  385.             if ok:
  386.                 alignType10Phase1(dev)
  387.                 state = 1
  388.  
  389.         elif state == 1:
  390.             values = align_ui(pattern, ALIGN_TYPE_LBOW)
  391.             log.debug(values)
  392.             alignType10Phase2(dev, values, pattern)
  393.             state = 2
  394.  
  395.         elif state == 2:
  396.             state = -1
  397.             ok = loadpaper_ui()
  398.             if ok:
  399.                 alignType10Phase3(dev)
  400.  
  401.  
  402. def alignType10Phase1(dev):
  403.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE,
  404.                          pml.PRINT_INTERNAL_PAGE_ALIGNMENT_PAGE)
  405.  
  406.     dev.closePrint()
  407.  
  408.  
  409. def alignType10Phase2(dev, values, pattern):
  410.     i, p = 0, ''.join([pcl.UEL, '\n'])
  411.  
  412.     for x in values:
  413.         i += 1
  414.         if not x:
  415.             break
  416.         p = ''.join([p, pcl.ESC, '*o5W\x1a', chr(i), '\x00', chr(pattern), chr(x), '\n'])
  417.  
  418.     p = ''.join([p, pcl.UEL]) 
  419.  
  420.     dev.printData(p)
  421.     dev.closePrint()
  422.  
  423. def alignType10Phase3(dev):
  424.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE,
  425.                          pml.PRINT_INTERNAL_PAGE_ALIGNMENT_PAGE_VERIFICATION)
  426.  
  427.     dev.closePrint()
  428.  
  429.  
  430. def align10and11Controls(pattern, align_type):
  431.     if align_type == ALIGN_TYPE_LIDIL_0_5_4:
  432.         if pattern == 1:
  433.             controls = { 'A' : (True, 23),
  434.                          'B' : (True, 9),
  435.                          'C' : (True, 9),
  436.                          'D' : (False, 0),
  437.                          'E' : (False, 0),
  438.                          'F' : (False, 0),
  439.                          'G' : (False, 0),
  440.                          'H' : (False, 0),}
  441.         elif pattern == 2: # K + color (ii)
  442.             controls = { 'A' : (True, 17),
  443.                          'B' : (True, 23),
  444.                          'C' : (True, 23),
  445.                          'D' : (True, 23),
  446.                          'E' : (True, 9),
  447.                          'F' : (True, 9),
  448.                          'G' : (True, 9),
  449.                          'H' : (True, 9),}
  450.  
  451.         elif pattern == 3: # color + photo (iii)
  452.             controls = { 'A' : (True, 9),
  453.                          'B' : (True, 23),
  454.                          'C' : (True, 23),
  455.                          'D' : (True, 23),
  456.                          'E' : (True, 9),
  457.                          'F' : (True, 9),
  458.                          'G' : (True, 9),
  459.                          'H' : (True, 9),}    
  460.  
  461.     else:
  462.         if pattern == 1:
  463.             controls = {'A' : (True, 23),
  464.                          'B' : (True, 9),
  465.                          'C' : (True, 9),
  466.                          'D' : (False, 0),
  467.                          'E' : (False, 0),
  468.                          'F' : (False, 0),
  469.                          'G' : (False, 0),
  470.                          'H' : (False, 0),}
  471.         elif pattern == 2:
  472.             controls = {'A' : (True, 23),
  473.                         'B' : (True, 17),
  474.                          'C' : (True, 23),
  475.                          'D' : (True, 23),
  476.                          'E' : (True, 9),
  477.                          'F' : (True, 9),
  478.                          'G' : (True, 9),
  479.                          'H' : (True, 9),}
  480.  
  481.         elif pattern == 3:
  482.             controls = {'A' : (True, 23),
  483.                          'B' : (True, 9),
  484.                          'C' : (True, 23),
  485.                          'D' : (True, 23),
  486.                          'E' : (True, 9),
  487.                          'F' : (True, 9),
  488.                          'G' : (True, 9),
  489.                          'H' : (True, 9),}
  490.  
  491.     return controls
  492.  
  493.  
  494. def AlignType11(dev, loadpaper_ui, align_ui, invalidpen_ui):
  495.     pen_config = status.getPenConfiguration(dev.getStatusFromDeviceID())
  496.     log.debug("Pen config=%d" % pen_config)
  497.  
  498.     if pen_config in (AGENT_CONFIG_BLACK_ONLY, AGENT_CONFIG_COLOR_ONLY): # (i)
  499.         pattern = 1
  500.  
  501.     if pen_config == AGENT_CONFIG_COLOR_AND_BLACK: # (ii)
  502.         pattern = 2
  503.  
  504.     elif pen_config == AGENT_CONFIG_COLOR_AND_PHOTO: # (iii)
  505.         pattern = 3
  506.  
  507.     elif pen_config == AGENT_CONFIG_PHOTO_ONLY:
  508.         invalidpen_ui()
  509.         return
  510.  
  511.     log.debug("Pattern=%d" % pattern)
  512.  
  513.     state = 0
  514.  
  515.     while state != -1:
  516.         if state == 0:
  517.             state = -1
  518.             ok = loadpaper_ui()
  519.             if ok:
  520.                 alignType11Phase1(dev)
  521.                 state = 1
  522.  
  523.         elif state == 1:
  524.             values = align_ui(pattern, ALIGN_TYPE_LIDIL_0_5_4)
  525.             log.debug(values)
  526.             alignType11Phase2(dev, values, pattern, pen_config)
  527.             state = 2
  528.  
  529.         elif state == 2:
  530.             state = -1
  531.             ok = loadpaper_ui()
  532.             if ok:
  533.                 alignType11Phase3(dev)
  534.  
  535.  
  536. def alignType11Phase1(dev):
  537.     dev.printData(ldl.buildResetPacket())
  538.     dev.printData(ldl.buildReportPagePacket(ldl.COMMAND_REPORT_PAGE_PEN_CALIBRATION))
  539.     dev.closePrint()
  540.  
  541.  
  542. def alignType11Phase2(dev, values, pattern, pen_config):
  543.     active_colors = 0
  544.  
  545.     if pen_config == AGENT_CONFIG_BLACK_ONLY:
  546.         active_colors = ldl.COMMAND_SET_PEN_ALIGNMENT_3_K
  547.         values = values[:3]
  548.  
  549.     elif pen_config == AGENT_CONFIG_COLOR_ONLY:
  550.         active_colors = COMMAND_SET_PEN_ALIGNMENT_3_COLOR
  551.         values = values[:3]
  552.  
  553.     elif pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  554.         active_colors = ldl.COMMAND_SET_PEN_ALIGNMENT_3_K | ldl.COMMAND_SET_PEN_ALIGNMENT_3_COLOR
  555.  
  556.     elif pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  557.         active_colors = ldl.COMMAND_SET_PEN_ALIGNMENT_3_COLOR | ldl.COMMAND_SET_PEN_ALIGNMENT_3_PHOTO
  558.  
  559.     log.debug("Active colors=0x%x Values=%s" % (active_colors, values))
  560.  
  561.     dev.printData(ldl.buildSetPenAlignment3Packet(active_colors, values))
  562.     dev.closePrint()
  563.  
  564.  
  565. def alignType11Phase3(dev):
  566.     dev.printData(ldl.buildReportPagePacket(ldl.COMMAND_REPORT_PAGE_PEN_CALIBRATION_VERIFY))
  567.     dev.closePrint()
  568.  
  569. def alignType2Phase1(dev): # Type 2 (8xx)
  570.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, 0)
  571.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, 0)
  572.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, 0)
  573.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, 0)
  574.     dev.closePrint()
  575.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align1_8xx.pcl.gz'))
  576.  
  577.  
  578. def alignType2Phase2(dev, a, b, c, d): # (8xx)
  579.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, (a - 6) * 12)
  580.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, (b - 6) * 12)
  581.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, (c - 3) * 12)
  582.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, (d - 3) * 12)
  583.     dev.writeEmbeddedPML(pml.OID_MARKING_AGENTS_INITIALIZED, 3)
  584.     dev.closePrint()
  585.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align2_8xx.pcl.gz'))
  586.  
  587.  
  588. def alignType3Phase1(dev): # Type 3 (9xx)
  589.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, 0)
  590.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, 0)
  591.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, 0)
  592.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, 0)
  593.     dev.closePrint()
  594.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align1_9xx.pcl.gz'))
  595.  
  596.  
  597. def alignType3Phase2(dev, a, b, c, d): # Type 3 (9xx)
  598.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, (a - 6) * 12)
  599.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, (6 - b) * 12)
  600.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, (6 - c) * 12)
  601.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, (6 - d) * 6)
  602.     dev.closePrint()
  603.  
  604. def alignType3Phase3(dev): # Type 3 (9xx)
  605.     dev.closePrint()
  606.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align3_9xx.pcl.gz'))
  607.  
  608.  
  609. def alignType3Phase4(dev, zca): # Type 3 (9xx)
  610.     dev.writeEmbeddedPML(pml.OID_MARKING_AGENTS_INITIALIZED, 3)
  611.     dev.closePrint()
  612.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align2_9xx.pcl.gz'))
  613.  
  614.  
  615. def alignType4Phase1(dev): # Type 4 (xBow/LIDIL 0.3.8)
  616.     dev.printData(ldl.buildLIDILPacket(ldl.PACKET_TYPE_RESUME_NORMAL_OPERATION))
  617.  
  618.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  619.         return
  620.  
  621.     elif dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  622.         ldl_file = 'cbbcal.ldl.gz'
  623.  
  624.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  625.         ldl_file = 'cbccal.ldl.gz'
  626.  
  627.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  628.         ldl_file = 'cb2pcal.ldl.gz'
  629.  
  630.     dev.printData(ldl.buildSetPrinterAlignmentPacket(0, 0, 0, 0))
  631.     dev.closePrint()
  632.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', ldl_file))
  633.  
  634.  
  635. def alignType4Phase2(dev, a, b, c, d, e): # Type 4 (LIDIL 0.3.8)
  636.     log.debug("A=%d, B=%d, C=%d, D=%d, E=%d" % (a, b, c, d, e))
  637.  
  638.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  639.         return
  640.  
  641.     # ZCA
  642.     zca = (7 - a) * -48
  643.     dev.printData(ldl.buildZCAPacket(zca))
  644.  
  645.     if dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  646.         k_bidi = (6 - b) * 2
  647.         dev.printData(ldl.buildSetPrinterAlignmentPacket(k_bidi, 0, 0, 0))
  648.  
  649.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  650.         cmy_bidi = (6 - b) * 2
  651.         dev.printData(ldl.buildSetPrinterAlignmentPacket(0, 0, 0, cmy_bidi))
  652.  
  653.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  654.         vert = (9 - b) * 2
  655.         hort = (9 - c) * -2
  656.         k_bidi = (6 - d) * 2
  657.         cmy_bidi = (6 - e) * 2
  658.  
  659.         dev.printData(ldl.buildSetPrinterAlignmentPacket(k_bidi, hort, vert, cmy_bidi))
  660.  
  661.     # Set alignment
  662.     dev.printData(ldl.buildSetPensAlignedPacket())
  663.     dev.closePrint()
  664.  
  665.  
  666. def alignType4Phase3(dev): # Type 4 (LIDIL 0.3.8)
  667.     if dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  668.         dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', 'cb2pcal_done.ldl.gz'))
  669.  
  670.  
  671. def alignType5Phase1(dev): # Type 5 (xBow+/LIDIL 0.4.3)
  672.     dev.printData(ldl.buildLIDILPacket(ldl.PACKET_TYPE_RESUME_NORMAL_OPERATION))
  673.  
  674.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  675.         return
  676.  
  677.     elif dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  678.         ldl_file = 'cbbcal.ldl.gz'
  679.  
  680.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  681.         ldl_file = 'cbpcal.ldl.gz'
  682.  
  683.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  684.         ldl_file = 'cbccal.ldl.gz'
  685.  
  686.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  687.         ldl_file = 'cb2pcal.ldl.gz'
  688.  
  689.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  690.         ldl_file = 'cbcpcal.ldl.gz'
  691.  
  692.     dev.printData(ldl.buildZCAPacket(0))
  693.     dev.printData(ldl.buildColorHortPacket(0))
  694.     dev.printData(ldl.buildColorVertPacket(0))
  695.     dev.printData(ldl.buildBlackVertPacket(0))
  696.     dev.printData(ldl.buildBlackHortPacket(0))
  697.     dev.printData(ldl.buildBlackBidiPacket(0))
  698.     dev.printData(ldl.buildColorBidiPacket(0))
  699.     dev.printData(ldl.buildPhotoHuePacket(0))
  700.     dev.printData(ldl.buildColorHuePacket(0))
  701.     dev.closePrint()
  702.  
  703.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', ldl_file))
  704.  
  705.  
  706. def alignType5Phase2(dev, a, b, c, d, e, f, g): # Type 5 (xBow+/LIDIL 0.4.3)
  707.     log.debug("A=%d, B=%d, C=%d, D=%d, E=%d, F=%d, G=%d" % (a, b, c, d, e, f, g))
  708.  
  709.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  710.         return
  711.  
  712.     # ZCA
  713.     zca = (7 - a) * -48
  714.     dev.printData(ldl.buildZCAPacket(zca))
  715.  
  716.     if dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  717.         k_bidi = (6 - b) * 2
  718.         dev.printData(ldl.buildBlackBidiPacket(k_bidi))
  719.  
  720.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  721.         kcm_bidi = (6 - b) * 2
  722.         dev.printData(ldl.buildPhotoBidiPacket(kcm_bidi))
  723.  
  724.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  725.         cmy_bidi = (6 - b) * 2
  726.         dev.printData(ldl.buildColorBidiPacket(cmy_bidi))
  727.  
  728.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  729.         vert = (9 - b) * 2
  730.         hort = (9 - c) * -2
  731.         k_bidi = (6 - d) * 2
  732.         cmy_bidi = (6 - e) * 2
  733.  
  734.         dev.printData(ldl.buildColorHortPacket(0))
  735.         dev.printData(ldl.buildColorVertPacket(0))
  736.         dev.printData(ldl.buildBlackVertPacket(vert))
  737.         dev.printData(ldl.buildBlackHortPacket(hort))
  738.         dev.printData(ldl.buildBlackBidiPacket(k_bidi))
  739.         dev.printData(ldl.buildColorBidiPacket(cmy_bidi))
  740.  
  741.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  742.         vert = (9 - b) * 2
  743.         hort = (9 - c) * -2
  744.         cmy_bidi = (6 - d) * 2
  745.         kcm_bidi = (6 - e) * 2
  746.  
  747.         photo_adj = colorcal.PHOTO_ALIGN_TABLE[f][g]
  748.         color_adj = colorcal.COLOR_ALIGN_TABLE[f][g]
  749.  
  750.         dev.printData(ldl.buildPhotoHortPacket(hort))
  751.         dev.printData(ldl.buildPhotoVertPacket(vert))
  752.         dev.printData(ldl.buildColorHortPacket(0))
  753.         dev.printData(ldl.buildColorVertPacket(0))
  754.         dev.printData(ldl.buildPhotoBidiPacket(kcm_bidi))
  755.         dev.printData(ldl.buildColorBidiPacket(cmy_bidi))
  756.         dev.printData(ldl.buildPhotoHuePacket(photo_adj))
  757.         dev.printData(ldl.buildColorHuePacket(color_adj))
  758.  
  759.     # Set alignment
  760.     dev.printData(ldl.buildSetPensAlignedPacket())
  761.     dev.closePrint()
  762.  
  763.  
  764. def alignType5Phase3(dev): # Type 5 (xBow+/LIDIL 0.4.3)
  765.     dev.closePrint()
  766.     if dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  767.         dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', "cb2pcal_done.ldl.gz"))
  768.  
  769.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  770.         dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', "cbccal_done.ldl.gz"))
  771.  
  772.  
  773. def alignType6Phase1(dev): # Type 6 (xBow AiO)
  774.     dev.printData(ldl.buildPrintInternalPagePacket())
  775.     dev.closePrint()
  776.  
  777. def alignType7Phase1(dev): # Type 7 (xBow VIP)
  778.     # Zero out all alignment values
  779.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, 0)
  780.  
  781.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, 0)
  782.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, 0)
  783.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, 0)
  784.  
  785.     dev.writeEmbeddedPML(pml.OID_AGENT3_VERTICAL_ALIGNMENT, 0)
  786.     dev.writeEmbeddedPML(pml.OID_AGENT3_HORIZONTAL_ALIGNMENT, 0)
  787.     dev.writeEmbeddedPML(pml.OID_AGENT3_BIDIR_ADJUSTMENT, 0)
  788.  
  789.     dev.writeEmbeddedPML(pml.OID_ZCA, 0)
  790.  
  791.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  792.         return
  793.  
  794.     elif dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  795.         pcl_file = 'crbcal.pcl.gz'
  796.  
  797.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  798.         pcl_file = 'crpcal.pcl.gz'
  799.  
  800.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  801.         pcl_file = 'crccal.pcl.gz'
  802.  
  803.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  804.         pcl_file = 'crcbcal.pcl.gz'
  805.  
  806.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  807.         pcl_file = 'crcpcal.pcl.gz'
  808.  
  809.     dev.closePrint()
  810.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', pcl_file))
  811.  
  812.  
  813. def alignType7Phase2(dev, a, b, c, d, e, f, g): # Type 7 (xBow VIP)
  814.     log.debug("A=%d, B=%d, C=%d, D=%d, E=%d, F=%d, G=%d" % (a, b, c, d, e, f, g))
  815.  
  816.     # ZCA
  817.     zca = (7 - a) * -12
  818.     dev.writeEmbeddedPML(pml.OID_ZCA, zca)
  819.  
  820.     if dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  821.         k_bidi = (6 - b) * 6
  822.         dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, k_bidi)
  823.  
  824.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  825.         kcm_bidi = (6 - b) * 6
  826.         dev.writeEmbeddedPML(pml.OID_AGENT3_BIDIR_ADJUSTMENT, kcm_bidi)
  827.  
  828.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  829.         cmy_bidi = (6 - b) * 6
  830.         dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, cmy_bidi)
  831.  
  832.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  833.         vert = (9 - b) * 6
  834.         hort = (9 - c) * -6
  835.         k_bidi = (6 - d) * 6
  836.         cmy_bidi = (6 - e) * 6
  837.  
  838.         dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, k_bidi)
  839.         dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, cmy_bidi)
  840.         dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, hort)
  841.         dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, vert)
  842.  
  843.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  844.         vert = (9 - b) * 6
  845.         hort = (9 - c) * -6
  846.         cmy_bidi = (6 - d) * 6
  847.         kcm_bidi = (6 - e) * 6
  848.  
  849.         photo_adj = colorcal.PHOTO_ALIGN_TABLE[f][g]
  850.         color_adj = colorcal.COLOR_ALIGN_TABLE[f][g]
  851.  
  852.         x = (color_adj << 8) + photo_adj
  853.  
  854.         dev.writeEmbeddedPML(pml.OID_COLOR_CALIBRATION_SELECTION, x)
  855.  
  856.         dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, cmy_bidi)
  857.         dev.writeEmbeddedPML(pml.OID_AGENT3_BIDIR_ADJUSTMENT, kcm_bidi)
  858.         dev.writeEmbeddedPML(pml.OID_AGENT3_HORIZONTAL_ALIGNMENT, hort)
  859.         dev.writeEmbeddedPML(pml.OID_AGENT3_VERTICAL_ALIGNMENT, vert)
  860.  
  861.     dev.closePrint()
  862.  
  863. def alignType7Phase3(dev): # Type 7 (xBow VIP)
  864.     dev.closePrint()
  865.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', "crcaldone.pcl.gz"))
  866.  
  867.  
  868. def alignType8Phase1(dev): # 450
  869.     pens = dev.getStatusFromDeviceID()['agents']
  870.     pen_types = [pens[x]['type'] for x in range(len(pens))]
  871.  
  872.     if AGENT_TYPE_KCM in pen_types:
  873.         f, num_inks = 'align6_450.pcl.gz', 6
  874.     else:
  875.         f, num_inks = 'align4_450.pcl.gz', 4
  876.  
  877.     dev.closePrint()
  878.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', f))
  879.  
  880.     return num_inks
  881.  
  882.  
  883. def alignType8Phase2(dev, num_inks, a, b, c, d): # 450
  884.     align_values1 = {1 : '\x00\x00\x18',
  885.                       2 : '\x00\x00\x12',
  886.                       3 : '\x00\x00\x0c',
  887.                       4 : '\x00\x00\x06',
  888.                       5 : '\x00\x00\x00',
  889.                       6 : '\x01\x00\x06',
  890.                       7 : '\x01\x00\x0c',
  891.                       8 : '\x01\x00\x12',
  892.                       9 : '\x01\x00\x18',
  893.                     }
  894.  
  895.     align_values2 = {1 : '\x00\x00\x12',
  896.                       2 : '\x00\x00\x0c',
  897.                       3 : '\x00\x00\x06',
  898.                       4 : '\x00\x00\x00',
  899.                       5 : '\x01\x00\x06',
  900.                       6 : '\x01\x00\x0c',
  901.                       7 : '\x01\x00\x12',
  902.                       8 : '\x01\x00\x18',
  903.                       9 : '\x01\x00\x1e',
  904.                     }
  905.  
  906.     align_values3 = {1 : '\x00\x00\x24',
  907.                       2 : '\x00\x00\x18',
  908.                       3 : '\x00\x00\x12',
  909.                       4 : '\x00\x00\x06',
  910.                       5 : '\x00\x00\x00',
  911.                       6 : '\x01\x00\x06',
  912.                       7 : '\x01\x00\x12',
  913.                       8 : '\x01\x00\x18',
  914.                       9 : '\x01\x00\x24',
  915.                     }
  916.  
  917.     if num_inks == 4:
  918.         s = ''.join([pcl.UEL,
  919.               '@PJL ENTER LANGUAGE=PCL3GUI\n',
  920.               pcl.RESET,
  921.               pcl.ESC, '*o5W\x1a\x01', align_values1[a],
  922.               pcl.ESC, '*o5W\x1a\x02', align_values2[a],
  923.               pcl.ESC, '*o5W\x1a\x03', align_values1[b],
  924.               pcl.ESC, '*o5W\x1a\x04', align_values1[b],
  925.               pcl.ESC, '*o5W\x1a\x08', align_values1[c],
  926.               pcl.ESC, '*o5W\x1a\x07', align_values1[d],
  927.               pcl.RESET,
  928.               pcl.UEL])
  929.  
  930.     else: # 6
  931.         s = ''.join([pcl.UEL,
  932.               '@PJL ENTER LANGUAGE=PCL3GUI\n',
  933.               pcl.RESET,
  934.               pcl.ESC, '*o5W\x1a\x05', align_values1[a],
  935.               pcl.ESC, '*o5W\x1a\x06', align_values3[a],
  936.               pcl.ESC, '*o5W\x1a\x03', align_values1[b],
  937.               pcl.ESC, '*o5W\x1a\x04', align_values1[b],
  938.               pcl.ESC, '*o5W\x1a\x0a', align_values1[c],
  939.               pcl.ESC, '*o5W\x1a\x09', align_values1[d],
  940.               pcl.RESET,
  941.               pcl.UEL])
  942.  
  943.     dev.printData(s)
  944.     dev.closePrint()
  945.     
  946.     
  947. def AlignType12(dev, loadpaper_ui):
  948.     if loadpaper_ui():
  949.         dev.setPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_ALIGNMENT_PAGE)
  950.         dev.closePML()
  951.  
  952. # ********************** Clean **********************
  953.  
  954.  
  955. def cleaning(dev, clean_type, level1, level2, level3,
  956.               loadpaper_ui, dlg1, dlg2, dlg3, wait_ui):
  957.  
  958.     state = 0
  959.  
  960.     while state != -1:
  961.         if state == 0: # Initial level1 print
  962.             state = 1
  963.             if clean_type == CLEAN_TYPE_PCL_WITH_PRINTOUT:
  964.                 ok = loadpaper_ui()
  965.                 if not ok:
  966.                     state = -1
  967.  
  968.         elif state == 1: # Do level 1
  969.             level1(dev)
  970.             state = 2
  971.  
  972.         elif state == 2: # Load plain paper
  973.             state = -1
  974.             ok = loadpaper_ui()
  975.             if ok:
  976.                 state = 3
  977.  
  978.         elif state == 3: # Print test page
  979.             state = 4
  980.             print_clean_test_page(dev)
  981.  
  982.         elif state == 4: # Need level 2?
  983.             state = -1
  984.             ok = dlg1()
  985.             if ok:
  986.                 state = 5
  987.  
  988.         elif state == 5: # Do level 2
  989.             level2(dev)
  990.             state = 6
  991.  
  992.         elif state == 6: # Load plain paper
  993.             state = -1
  994.             ok = loadpaper_ui()
  995.             if ok:
  996.                 state = 7
  997.  
  998.         elif state == 7: # Print test page
  999.             state = 8
  1000.             print_clean_test_page(dev)
  1001.  
  1002.         elif state == 8: # Need level 3?
  1003.             state = -1
  1004.             ok = dlg2()
  1005.             if ok:
  1006.                 state = 9
  1007.  
  1008.         elif state == 9: # Do level 3
  1009.             level3(dev)
  1010.             state = 10
  1011.  
  1012.         elif state == 10: # Load plain paper
  1013.             state = -1
  1014.             ok = loadpaper_ui()
  1015.             if ok:
  1016.                 state = 11
  1017.  
  1018.         elif state == 11: # Print test page
  1019.             state = 12
  1020.             print_clean_test_page(dev)
  1021.  
  1022.         elif state == 12:
  1023.             state = -1
  1024.             dlg3()
  1025.  
  1026.     return ok
  1027.  
  1028.  
  1029. def print_clean_test_page(dev):
  1030.     dev.closePrint()
  1031.     dev.printGzipFile(os.path.join(prop.home_dir, 'data',
  1032.                       'ps', 'clean_page.pdf.gz'), raw=False)
  1033.  
  1034. def cleanType1(dev): # PCL, Level 1
  1035.     dev.writeEmbeddedPML(pml.OID_CLEAN, pml.CLEAN_CLEAN)
  1036.     dev.closePrint()
  1037.  
  1038. def primeType1(dev): # PCL, Level 2
  1039.     dev.writeEmbeddedPML(pml.OID_CLEAN, pml.CLEAN_PRIME)
  1040.     dev.closePrint()
  1041.  
  1042. def wipeAndSpitType1(dev): # PCL, Level 3
  1043.     dev.writeEmbeddedPML(pml.OID_CLEAN, pml.CLEAN_WIPE_AND_SPIT)
  1044.     dev.closePrint()
  1045.  
  1046. def cleanType2(dev): # LIDIL, Level 1
  1047.     dev.printData(ldl.buildResetPacket())
  1048.     dev.printData(ldl.buildLIDILPacket(ldl.PACKET_TYPE_COMMAND,
  1049.                                        ldl.COMMAND_HANDLE_PEN,
  1050.                                        ldl.COMMAND_HANDLE_PEN_CLEAN_LEVEL1))
  1051.     dev.closePrint()
  1052.  
  1053. def primeType2(dev): # LIDIL, Level 2
  1054.     dev.printData(ldl.buildResetPacket())
  1055.     dev.printData(ldl.buildLIDILPacket(ldl.PACKET_TYPE_COMMAND,
  1056.                                        ldl.COMMAND_HANDLE_PEN,
  1057.                                        ldl.COMMAND_HANDLE_PEN_CLEAN_LEVEL2))
  1058.     dev.closePrint()
  1059.  
  1060. def wipeAndSpitType2(dev): # LIDIL, Level 3
  1061.     dev.printData(ldl.buildResetPacket())
  1062.     dev.printData(ldl.buildLIDILPacket(ldl.PACKET_TYPE_COMMAND,
  1063.                                        ldl.COMMAND_HANDLE_PEN,
  1064.                                        ldl.COMMAND_HANDLE_PEN_CLEAN_LEVEL3))
  1065.     dev.closePrint()
  1066.  
  1067.  
  1068. # ********************** Color Cal **********************
  1069.  
  1070.  
  1071. def colorCalType1(dev, loadpaper_ui, colorcal_ui, photopenreq_ui): # 450
  1072.     value, state = 4, 0
  1073.     ok = False
  1074.     while state != -1:
  1075.  
  1076.         if state == 0:
  1077.             if colorCalType1PenCheck(dev):
  1078.                 state = 1
  1079.             else:
  1080.                 state = 100
  1081.  
  1082.         elif state == 1:
  1083.             state = -1
  1084.             ok = loadpaper_ui()
  1085.             if ok:
  1086.                 colorCalType1Phase1(dev)
  1087.                 state = 2
  1088.  
  1089.         elif state == 2:
  1090.             state = -1
  1091.             ok, value = colorcal_ui()
  1092.             if ok:
  1093.                 state = 3
  1094.  
  1095.         elif state == 3:
  1096.             colorCalType1Phase2(dev, value)
  1097.             state = -1
  1098.  
  1099.         elif state == 100:
  1100.             ok = False
  1101.             photopenreq_ui()
  1102.             state = -1
  1103.  
  1104.     return ok
  1105.  
  1106.  
  1107. def colorCalType1PenCheck(dev): # 450
  1108.     pens = dev.getStatusFromDeviceID()['agents']
  1109.     pen_types = [pens[x]['type'] for x in range(len(pens))]
  1110.  
  1111.     if AGENT_TYPE_KCM in pen_types:
  1112.         return True
  1113.  
  1114.     else:
  1115.         log.error("Cannot perform color calibration with no photo pen installed.")
  1116.         return False
  1117.  
  1118.  
  1119. def colorCalType1Phase1(dev): # 450
  1120.     dev.closePrint()
  1121.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'colorcal1_450.pcl.gz'))
  1122.  
  1123.  
  1124. def colorCalType1Phase2(dev, value): # 450
  1125.     color_cal = {1 : ('\x0f\x3c', '\x17\x0c'),
  1126.                   2 : ('\x10\xcc', '\x15\x7c'),
  1127.                   3 : ('\x12\x5c', '\x13\xec'),
  1128.                   4 : ('\x13\xec', '\x12\x5c'),
  1129.                   5 : ('\x15\x7c', '\x10\xcc'),
  1130.                   6 : ('\x17\x0c', '\x0f\x3c'),
  1131.                   7 : ('\x18\x9c', '\x0d\xac'),
  1132.                 }
  1133.  
  1134.     s = ''.join([pcl.UEL,
  1135.                   '@PJL ENTER LANGUAGE=PCL3GUI\n',
  1136.                   pcl.RESET,
  1137.                   pcl.ESC, '*o5W\x1a\x0c\x00', color_cal[value][0],
  1138.                   pcl.ESC, '*o5W\x1a\x0b\x00', color_cal[value][1],
  1139.                   pcl.RESET,
  1140.                   pcl.UEL])
  1141.  
  1142.     dev.printData(s)
  1143.     dev.closePrint()
  1144.  
  1145. #
  1146. # COLOR CAL TYPE 2
  1147. #
  1148.  
  1149. def colorCalType2(dev, loadpaper_ui, colorcal_ui, photopenreq_ui):
  1150.     value, state = 4, 0
  1151.     ok = True
  1152.     while state != -1:
  1153.  
  1154.         if state == 0:
  1155.             if colorCalType2PenCheck(dev):
  1156.                 state = 1
  1157.             else:
  1158.                 state = 100
  1159.  
  1160.         elif state == 1:
  1161.             state = -1
  1162.             ok = loadpaper_ui()
  1163.             if ok:
  1164.                 colorCalType2Phase1(dev)
  1165.                 state = 2
  1166.  
  1167.         elif state == 2:
  1168.             state = -1
  1169.             ok, value = colorcal_ui()
  1170.             if ok:
  1171.                 state = 3
  1172.  
  1173.         elif state == 3:
  1174.             colorCalType2Phase2(dev, value)
  1175.             state = -1
  1176.  
  1177.         elif state == 100:
  1178.             photopenreq_ui()
  1179.             ok = False
  1180.             state = -1
  1181.  
  1182.     return ok
  1183.  
  1184. def colorCalType2PenCheck(dev):
  1185.     pens = dev.getStatusFromDeviceID()['agents']
  1186.     pen_types = [pens[x]['type'] for x in range(len(pens))]
  1187.  
  1188.     if not AGENT_TYPE_NONE in pen_types:
  1189.         return True
  1190.  
  1191.     else:
  1192.         log.error("Cannot perform color calibration with pens missing.")
  1193.         return False
  1194.  
  1195. def colorCalType2Phase1(dev):
  1196.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE,
  1197.                          pml.PRINT_INTERNAL_PAGE_COLOR_CAL)
  1198.  
  1199.     dev.closePrint()
  1200.  
  1201.  
  1202. def colorCalType2Phase2(dev, value):
  1203.     c = colorcal.COLOR_CAL_TABLE
  1204.     p = ''.join(['\x1b&b19WPML \x04\x00\x06\x01\x04\x01\x05\x01\t\x08\x04',
  1205.                    chr(c[value*4]+100), chr(c[value*4+1]+100),
  1206.                    chr(c[value*4+2]+100), chr(c[value*4+3]+100),
  1207.                    '\x1b%-12345X'])
  1208.  
  1209.     dev.printData(p)
  1210.     dev.closePrint()
  1211.  
  1212.  
  1213. #
  1214. # COLOR CAL TYPE 3
  1215. #
  1216.  
  1217. def colorCalType3(dev, loadpaper_ui, colorcal_ui, photopenreq_ui):
  1218.     value, state = 4, 0
  1219.     ok = True
  1220.     while state != -1:
  1221.  
  1222.         if state == 0:
  1223.             if colorCalType3PenCheck(dev):
  1224.                 state = 1
  1225.             else:
  1226.                 state = 100
  1227.  
  1228.         elif state == 1:
  1229.             state = -1
  1230.             ok = loadpaper_ui()
  1231.             if ok:
  1232.                 colorCalType3Phase1(dev)
  1233.                 state = 2
  1234.  
  1235.         elif state == 2:
  1236.             state = -1
  1237.             ok, valueA = colorcal_ui('A', 21)
  1238.             if ok:
  1239.                 state = 3
  1240.  
  1241.         elif state == 3:
  1242.             state = -1
  1243.             ok, valueB = colorcal_ui('B', 21)
  1244.             if ok:
  1245.                 state = 4
  1246.  
  1247.         elif state == 4:
  1248.             colorCalType3Phase2(dev, valueA, valueB)
  1249.             state = -1
  1250.  
  1251.         elif state == 100:
  1252.             photopenreq_ui()
  1253.             ok = False
  1254.             state = -1
  1255.  
  1256.     return ok
  1257.  
  1258. def colorCalType3PenCheck(dev):
  1259.     pens = dev.getStatusFromDeviceID()['agents']
  1260.     pen_types = [pens[x]['type'] for x in range(len(pens))]
  1261.  
  1262.     if AGENT_TYPE_KCM in pen_types or \
  1263.       AGENT_TYPE_BLUE in pen_types:
  1264.         return True
  1265.  
  1266.     else:
  1267.         log.error("Cannot perform color calibration with no photo (or photo blue) pen installed.")
  1268.         return False
  1269.  
  1270.  
  1271. def colorCalType3Phase1(dev):
  1272.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE,
  1273.                          pml.PRINT_INTERNAL_PAGE_COLOR_CAL)
  1274.     dev.closePrint()
  1275.  
  1276. def colorCalType3Phase2(dev, A, B):
  1277.     photo_adj = colorcal.PHOTO_ALIGN_TABLE[A-1][B-1]
  1278.     color_adj = colorcal.COLOR_ALIGN_TABLE[A-1][B-1]
  1279.     adj_value = (color_adj << 8L) + photo_adj
  1280.  
  1281.     dev.writeEmbeddedPML(pml.OID_COLOR_CALIBRATION_SELECTION, adj_value)
  1282.     dev.closePrint()
  1283.  
  1284. def colorCalType4(dev, loadpaper_ui, colorcal_ui, wait_ui):
  1285.     state = 0
  1286.     ok = True
  1287.  
  1288.     while state != -1:
  1289.         if state == 0:
  1290.             state = -1
  1291.             ok = loadpaper_ui()
  1292.             if ok:
  1293.                 colorCalType4Phase1(dev)
  1294.                 state = 2
  1295.  
  1296.         elif state == 2:
  1297.             state = -1
  1298.             #wait_ui(90)
  1299.             ok, values = colorcal_ui()
  1300.             if ok:
  1301.                 state = 3
  1302.  
  1303.         elif state == 3:
  1304.             colorCalType4Phase2(dev, values)
  1305.             #wait_ui(5)
  1306.             state = 4
  1307.  
  1308.         elif state == 4:
  1309.             state = -1
  1310.             ok = loadpaper_ui()
  1311.             if ok:
  1312.                 colorCalType4Phase3(dev)
  1313.                 state = -1
  1314.  
  1315.     return ok
  1316.  
  1317.  
  1318. def colorCalType4Phase1(dev):
  1319.     dev.setPML(pml.OID_PRINT_INTERNAL_PAGE,
  1320.               pml.PRINT_INTERNAL_PAGE_COLOR_CAL)
  1321.               
  1322.     dev.closePML()
  1323.  
  1324.  
  1325. def colorCalType4AdjValue(value):
  1326.     if value >= 100:
  1327.         return 200
  1328.     return value+100
  1329.  
  1330.  
  1331. def colorCalType4Phase2(dev, values):
  1332.     if -1 in values:
  1333.         Cadj, Madj, Yadj, cadj, madj, kadj = 244, 244, 244, 244, 244, 244
  1334.     else:
  1335.         sel1, sel2, sel3, sel4 = values
  1336.         tmp1 = colorcal.TYPE_4_C_TABLE[sel1][sel2]
  1337.         tmp2 = colorcal.TYPE_4_LC_TABLE[sel3][sel4]
  1338.  
  1339.         Cadj = colorCalType4AdjValue(tmp1)
  1340.         cadj = colorCalType4AdjValue(tmp1+tmp2)
  1341.  
  1342.         tmp1 = colorcal.TYPE_4_M_TABLE[sel1][sel2]
  1343.         tmp2 = colorcal.TYPE_4_LM_TABLE[sel3][sel4]
  1344.  
  1345.         Madj = colorCalType4AdjValue(tmp1)
  1346.         madj = colorCalType4AdjValue(tmp1+tmp2)
  1347.  
  1348.         Yadj = colorCalType4AdjValue(colorcal.TYPE_4_Y_TABLE[sel1][sel2])
  1349.         kadj = colorCalType4AdjValue(0)
  1350.  
  1351.     log.debug("C=%d, M=%d, Y=%d, c=%d, m=%d, k=%d\n" % (Cadj, Madj, Yadj, cadj, madj, kadj))
  1352.  
  1353.     dev.setPML(pml.OID_COLOR_CALIBRATION_ARRAY_1,
  1354.                             kadj)
  1355.                             
  1356.     dev.setPML(pml.OID_COLOR_CALIBRATION_ARRAY_2,
  1357.                             Cadj)
  1358.                             
  1359.     dev.setPML(pml.OID_COLOR_CALIBRATION_ARRAY_3,
  1360.                             Madj)
  1361.     
  1362.     dev.setPML(pml.OID_COLOR_CALIBRATION_ARRAY_4,
  1363.                             Yadj)
  1364.                             
  1365.     dev.setPML(pml.OID_COLOR_CALIBRATION_ARRAY_5,
  1366.                             cadj)
  1367.     
  1368.     dev.setPML(pml.OID_COLOR_CALIBRATION_ARRAY_6,
  1369.                             madj)
  1370.                             
  1371.     dev.closePML()
  1372.  
  1373.  
  1374. def colorCalType4Phase3(dev):
  1375.     dev.setPML(pml.OID_PRINT_INTERNAL_PAGE,
  1376.                          pml.PRINT_INTERNAL_PAGE_COLOR_PALETTE_CMYK_PAGE)
  1377.                          
  1378.     dev.closePML()
  1379.  
  1380.  
  1381. def colorCalType5(dev, loadpaper_ui):
  1382.     if loadpaper_ui():
  1383.         dev.printData("""\x1b%-12345X@PJL ENTER LANGUAGE=PCL3GUI\n\x1bE\x1b%Puifp.multi_button_push 20;\nudw.quit;\x1b*rC\x1bE\x1b%-12345X""")
  1384.         dev.closePrint()
  1385.  
  1386.         
  1387. def colorCalType6(dev, loadpaper_ui):
  1388.     if loadpaper_ui():
  1389.         dev.setPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_COLOR_CAL)
  1390.         dev.closePML()
  1391.         
  1392. def colorCalType7(dev, loadpaper_ui):
  1393.     if loadpaper_ui():
  1394.         dev.setPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_AUTOMATIC_COLOR_CALIBRATION)
  1395.         dev.closePML()
  1396.  
  1397. # ********************** LF Cal **********************        
  1398.         
  1399. def linefeedCalType1(dev, loadpaper_ui):
  1400.     if loadpaper_ui():
  1401.         dev.printData("""\x1b%-12345X@PJL ENTER LANGUAGE=PCL3GUI\n\x1bE\x1b%Puifp.multi_button_push 3;\nudw.quit;\x1b*rC\x1bE\x1b%-12345X""")
  1402.         dev.closePrint()
  1403.         
  1404. def linefeedCalType2(dev, loadpaper_ui):
  1405.     if loadpaper_ui():
  1406.         dev.setPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_LINEFEED_CALIBRATION)
  1407.         dev.closePML()
  1408.  
  1409.  
  1410. # ********************** PQ Diag **********************        
  1411.         
  1412. def printQualityDiagType1(dev, loadpaper_ui):
  1413.     if loadpaper_ui():
  1414.         dev.printData("""\x1b%-12345X@PJL ENTER LANGUAGE=PCL3GUI\n\x1bE\x1b%Puifp.multi_button_push 14;\nudw.quit;\x1b*rC\x1bE\x1b%-12345X""")
  1415.         dev.closePrint()
  1416.  
  1417. def printQualityDiagType2(dev, loadpaper_ui):
  1418.     if loadpaper_ui():
  1419.         dev.setPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_PRINT_QUALITY_DIAGNOSTIC)
  1420.         dev.closePML()
  1421.